home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / util / primitives / structures.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  13KB  |  393 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from mapping import Storage, to_storage
  5. import logging
  6. import struct
  7. log = logging.getLogger('util.primitives.structures')
  8.  
  9. class enum(list):
  10.     
  11.     def __init__(self, *args):
  12.         list.__init__(self, args)
  13.  
  14.     
  15.     def __getattr__(self, elem):
  16.         return self.index(elem)
  17.  
  18.     
  19.     def __getitem__(self, i):
  20.         if isinstance(i, basestring):
  21.             return self.__getattr__(i)
  22.         else:
  23.             return list.__getitem__(self, i)
  24.  
  25.  
  26.  
  27. def new_packable(fmt, byteorder = '!', invars = None):
  28.     if not invars:
  29.         pass
  30.     invars = []
  31.     slots = fmt[::2]
  32.     fmtstring = byteorder + ''.join(fmt[1::2])
  33.     
  34.     class packable(None, 'packable', (object,)):
  35.         __slots__ = slots
  36.         _fmt = fmtstring
  37.         invariants = invars
  38.         
  39.         def unpack(cls, data):
  40.             o = cls(*struct.unpack(cls._fmt, data))
  41.             return o
  42.  
  43.         unpack = classmethod(unpack)
  44.         
  45.         def __init__(self, *a, **kw):
  46.             i = -1
  47.             for i, d in enumerate(a):
  48.                 setattr(self, self.__slots__[i], d)
  49.             
  50.             for field in self.__slots__[i + 1:]:
  51.                 setattr(self, field, 0)
  52.             
  53.             for k in kw:
  54.                 setattr(self, k, kw[k])
  55.             
  56.  
  57.         
  58.         def pack(self):
  59.             return struct.pack((self._fmt,), *(lambda .0: for field in .0:
  60. getattr(self, field))(self.__slots__))
  61.  
  62.         
  63.         def __iter__(self):
  64.             return (lambda .0: for s in .0:
  65. (s, getattr(self, s)))(self.__slots__)
  66.  
  67.         
  68.         def __len__(self):
  69.             return struct.calcsize(self._fmt)
  70.  
  71.         __str__ = pack
  72.         
  73.         def __eq__(self, other):
  74.             o = ()
  75.             for slot in self.__slots__:
  76.                 sval = getattr(self, slot)
  77.                 oval = getattr(other, slot, o)
  78.                 if oval is o:
  79.                     return False
  80.                 
  81.                 if oval != sval:
  82.                     return False
  83.                     continue
  84.             
  85.             return True
  86.  
  87.         
  88.         def __ne__(self, other):
  89.             return not self.__eq__(other)
  90.  
  91.         
  92.         def copy(self):
  93.             return self.unpack(self.pack())
  94.  
  95.  
  96.     return packable
  97.  
  98.  
  99. def unpack_named(format, *args):
  100.     data = args[-1]
  101.     rest = None
  102.     if 'R' in format:
  103.         if format.find('R') != len(format) - 1:
  104.             raise AssertionError('R character in format string to unpack_named can only appear at the end')
  105.         else:
  106.             format = format[:-1]
  107.             sz = struct.calcsize(format)
  108.             rest = data[sz:]
  109.             data = data[:sz]
  110.     
  111.     tup = struct.unpack(format, data)
  112.     magic_hash = { }
  113.     for i in xrange(len(tup)):
  114.         magic_hash[args[i]] = tup[i]
  115.     
  116.     if rest:
  117.         magic_hash[args[i + 1]] = rest
  118.     
  119.     return to_storage(magic_hash)
  120.  
  121.  
  122. def remove_from_list(my_list, remove_these):
  123.     my_list = my_list[:]
  124.     remove_list = _[1]
  125.     for e in remove_list:
  126.         my_list.remove(e)
  127.     
  128.     return my_list
  129.  
  130.  
  131. class oset(set):
  132.     
  133.     def __init__(self, iterable = []):
  134.         self.data = []
  135.         self.update(iterable, init = True)
  136.  
  137.     
  138.     def add(self, val):
  139.         if val not in self.data:
  140.             self.data.append(val)
  141.             set.add(self, val)
  142.         
  143.  
  144.     
  145.     def __getitem__(self, n):
  146.         return self.data[n]
  147.  
  148.     
  149.     def __iter__(self):
  150.         return iter(self.data)
  151.  
  152.     
  153.     def clear(self):
  154.         del self.data[:]
  155.         set.clear(self)
  156.  
  157.     
  158.     def pop(self):
  159.         ret = set.pop(self)
  160.         self.data.remove(ret)
  161.         return ret
  162.  
  163.     
  164.     def remove(self, item):
  165.         self.data.remove(item)
  166.         set.remove(self, item)
  167.  
  168.     
  169.     def discard(self, item):
  170.         
  171.         try:
  172.             self.remove(item)
  173.         except ValueError:
  174.             pass
  175.         except KeyError:
  176.             pass
  177.  
  178.  
  179.     
  180.     def union(self, other):
  181.         if not isinstance(other, oset):
  182.             other = oset(other)
  183.         
  184.         return self | other
  185.  
  186.     
  187.     def __or__(self, other):
  188.         if not isinstance(other, set):
  189.             raise ValueError, 'other must be a set'
  190.         
  191.         ret = oset(self)
  192.         ret.update(other)
  193.         return ret
  194.  
  195.     
  196.     def intersection(self, other):
  197.         if not isinstance(other, oset):
  198.             other = oset(other)
  199.         
  200.         return self & other
  201.  
  202.     
  203.     def __and__(self, other):
  204.         if not isinstance(other, set):
  205.             raise ValueError, 'other must be a set'
  206.         
  207.         a = oset(self)
  208.         b = other
  209.         return a - a - b
  210.  
  211.     
  212.     def difference(self, other):
  213.         other = oset(other)
  214.         return self - other
  215.  
  216.     
  217.     def __sub__(self, other):
  218.         if not isinstance(other, set):
  219.             raise ValueError, 'other must be a set'
  220.         
  221.         first = oset(self)
  222.         first -= other
  223.         return first
  224.  
  225.     
  226.     def symmetric_difference(self, other):
  227.         if not isinstance(other, oset):
  228.             other = oset(other)
  229.         
  230.         return self ^ other
  231.  
  232.     
  233.     def __xor__(self, other):
  234.         if not isinstance(other, set):
  235.             raise ValueError, 'other must be a set'
  236.         
  237.         return (self | other) - (self & other)
  238.  
  239.     
  240.     def copy(self):
  241.         return oset(self)
  242.  
  243.     
  244.     def update(self, other, init = False):
  245.         if not isinstance(other, oset) and not init:
  246.             other = oset(other)
  247.         
  248.         self.__ior__(other, init = init)
  249.  
  250.     
  251.     def __ior__(self, other, init = False):
  252.         if not isinstance(other, set) and not init:
  253.             raise ValueError, 'other must be a set'
  254.         
  255.         for i in other:
  256.             self.add(i)
  257.         
  258.         return self
  259.  
  260.     
  261.     def intersection_update(self, other):
  262.         if not isinstance(other, oset):
  263.             other = oset(other)
  264.         
  265.         self &= other
  266.  
  267.     
  268.     def __iand__(self, other):
  269.         if not isinstance(other, set):
  270.             raise ValueError, 'other must be a set'
  271.         
  272.         self -= self & other
  273.  
  274.     
  275.     def difference_update(self, other):
  276.         if not isinstance(other, oset):
  277.             other = oset(other)
  278.         
  279.         self -= other
  280.  
  281.     
  282.     def __isub__(self, other):
  283.         if not isinstance(other, set):
  284.             raise ValueError, 'other must be a set'
  285.         
  286.         for item in other:
  287.             self.discard(item)
  288.         
  289.         return self
  290.  
  291.     
  292.     def symmetric_difference_update(self, other):
  293.         if not isinstance(other, oset):
  294.             other = oset(other)
  295.         
  296.         self ^= other
  297.  
  298.     
  299.     def __ixor__(self, other):
  300.         if not isinstance(other, set):
  301.             raise ValueError, 'other must be a set'
  302.         
  303.         b = oset(other)
  304.         b -= self
  305.         self -= other
  306.         self |= b
  307.         return self
  308.  
  309.  
  310.  
  311. class roset(oset):
  312.     
  313.     def add(self, val):
  314.         if val in self:
  315.             self.data.remove(val)
  316.             self.data.append(val)
  317.         else:
  318.             oset.add(self, val)
  319.  
  320.     
  321.     def insert(self, idx, item):
  322.         if item in self:
  323.             self.data.remove(item)
  324.         
  325.         self.data.insert(idx, item)
  326.         set.add(self, item)
  327.  
  328.  
  329.  
  330. class EmptyQueue(Exception):
  331.     pass
  332.  
  333.  
  334. class PriorityQueue(object):
  335.     default_priority = 5
  336.     
  337.     def __init__(self, *args):
  338.         self.q = [ (self.default_priority, arg) for arg in args ]
  339.         
  340.         self.key = lambda a: a[0]
  341.         self.q.sort(key = self.key)
  342.  
  343.     
  344.     def __len__(self):
  345.         return len(self.q)
  346.  
  347.     
  348.     def count(self, x):
  349.         return self.q.count(x)
  350.  
  351.     
  352.     def peek(self):
  353.         if not self.q:
  354.             raise EmptyQueue
  355.         
  356.         (__, item) = self.q[0]
  357.         return item
  358.  
  359.     
  360.     def __iadd__(self, elemtuple):
  361.         if isinstance(elemtuple, (tuple, list)):
  362.             if len(elemtuple) != 2:
  363.                 raise TypeError('add to the PriorityQueue like += (item, priority) or just += item')
  364.             
  365.             self.append(*elemtuple)
  366.         else:
  367.             self.append(elemtuple)
  368.         return self
  369.  
  370.     
  371.     def __nonzero__(self):
  372.         return self.q.__len__()
  373.  
  374.     
  375.     def append(self, item, priority = default_priority):
  376.         self.q.append((priority, item))
  377.         self.q.sort(key = self.key)
  378.  
  379.     
  380.     def next(self):
  381.         (__, item) = self.q.pop(0)
  382.         return item
  383.  
  384.     
  385.     def __repr__(self):
  386.         return '<PriorityQueue %r>' % self.q
  387.  
  388.  
  389. if __name__ == '__main__':
  390.     import doctest
  391.     doctest.testmod(verbose = True)
  392.  
  393.